#include "../src/Server.hpp"

// int main()
// {
//     Socket sock;
//     sock.CreateServer(9000);
//     int sockfd = sock.Accept();
//     while(true)
//     {
//         char buf[1024] = { 0 };
//         int n = recv(sockfd, buf, 1023, 0);
//         if(n < 0) abort();
//         if(n == 0)
//         {
//             DBG_LOG("socket has closed");
//             return 0;
//         }

//         DBG_LOG("client say: %s", buf);
//     }

//     return 0;
// }



// void ClosedCB(Channel* channel)
// {
//     DBG_LOG("closed socket fd: %d", channel->Fd());
//     channel->RemoveEvents();
//     delete channel;
// }
// void MessageCB(Channel* channel)
// {
//     DBG_LOG("读事件处理回调");
//     char buf[1024] = { 0 };
//     int n = recv(channel->Fd(), buf, 1023, 0);
//     if(n <= 0)// 读取出错或连接断开
//     {
//         ERR_LOG("server recv failed，close socket");
//         ClosedCB(channel);
//         return;
//     }

//     DBG_LOG("client say: %s", buf);

//     // 接收到数据才会发送数据
//     channel->EnableWrite();
// }
// void WriteCB(Channel* channel)
// {
//     DBG_LOG("写事件处理回调");
//     const char* str = "hello world";
//     int n = send(channel->Fd(), str, strlen(str), 0);
//     if(n < 0)
//     {
//         ERR_LOG("server send failed， close socket");
//         ClosedCB(channel);
//         return;
//     }

//     // 发送完数据就关闭可写监控，等待客户端数据到来再发送
//     channel->DisableWrite();
// }
// void ErrorCB(Channel* channel)
// {
//     DBG_LOG("错误事件处理回调");
//     ClosedCB(channel);
// }
// void EventCB(Channel* channel)
// {
//     DBG_LOG("有事件就绪");
// }

// void Accept(Channel* channel, Poller* poller)
// {
//     int new_sockfd = accept(channel->Fd(), nullptr, nullptr);// 获取新连接
//     if(new_sockfd < 0)
//     {
//         ERR_LOG("socket accept failed");
//         abort();
//     }

//     // 为新的通信连接创造Channel对象管理新连接上的事件监控
//     Channel* new_channel = new Channel(new_sockfd, poller);
//     // 为新连接的Channel对象设置事件被触发的回调函数
//     new_channel->SetReadCallback(std::bind(MessageCB, new_channel));
//     new_channel->SetWriteCallback(std::bind(WriteCB, new_channel));
//     new_channel->SetClosedCallback(std::bind(ClosedCB, new_channel));
//     new_channel->SetErrorCallback(std::bind(ErrorCB, new_channel));
//     new_channel->SetEventCallback(std::bind(EventCB, new_channel));
//     // 启动读事件监控
//     new_channel->EnableRead();

//     DBG_LOG("new socket come");
// }

// int main()
// {
//     Socket sock;
//     assert(sock.CreateServer(9000));
//     DBG_LOG("server socket created %d", sock.Fd());

//     Poller poller;
//     Channel channel(sock.Fd(), &poller);
//     channel.SetReadCallback(std::bind(Accept, &channel, &poller));
//     channel.EnableRead();

//     while(true)
//     {
//         std::vector<Channel*> actives;
//         poller.Poll(actives);
//         for(auto& it : actives)
//         {
//             it->HandleEvent();
//         }
//     }

//     return 0;
// }




// void ClosedCB(Channel* channel)
// {
//     DBG_LOG("closed socket fd: %d", channel->Fd());
//     channel->RemoveEvents();
//     delete channel;
// }
// void MessageCB(Channel* channel)
// {
//     DBG_LOG("读事件处理回调");
//     char buf[1024] = { 0 };
//     int n = recv(channel->Fd(), buf, 1023, 0);
//     if(n <= 0)// 读取出错或连接断开
//     {
//         ERR_LOG("server recv failed，close socket");
//         ClosedCB(channel);
//         return;
//     }

//     DBG_LOG("client say: %s", buf);

//     // 接收到数据才会发送数据
//     channel->EnableWrite();
// }
// void WriteCB(Channel* channel)
// {
//     DBG_LOG("写事件处理回调");
//     const char* str = "hello world";
//     int n = send(channel->Fd(), str, strlen(str), 0);
//     if(n < 0)
//     {
//         ERR_LOG("server send failed， close socket");
//         ClosedCB(channel);
//         return;
//     }

//     // 发送完数据就关闭可写监控，等待客户端数据到来再发送
//     channel->DisableWrite();
// }
// void ErrorCB(Channel* channel)
// {
//     DBG_LOG("错误事件处理回调");
//     ClosedCB(channel);
// }
// void EventCB(Channel* channel)
// {
//     DBG_LOG("有事件就绪");
// }

// void Accept(Channel* channel, EventLoop* eventloop)
// {
//     int new_sockfd = accept(channel->Fd(), nullptr, nullptr);// 获取新连接
//     if(new_sockfd < 0)
//     {
//         ERR_LOG("socket accept failed");
//         abort();
//     }

//     // 为新的通信连接创造Channel对象管理新连接上的事件监控
//     Channel* new_channel = new Channel(new_sockfd, eventloop);
//     // 为新连接的Channel对象设置事件被触发的回调函数
//     new_channel->SetReadCallback(std::bind(MessageCB, new_channel));
//     new_channel->SetWriteCallback(std::bind(WriteCB, new_channel));
//     new_channel->SetClosedCallback(std::bind(ClosedCB, new_channel));
//     new_channel->SetErrorCallback(std::bind(ErrorCB, new_channel));
//     new_channel->SetEventCallback(std::bind(EventCB, new_channel));
//     // 启动读事件监控
//     new_channel->EnableRead();

//     DBG_LOG("new socket come");
// }

// int main()
// {
//     Socket sock;
//     assert(sock.CreateServer(9000));
//     DBG_LOG("server socket created %d", sock.Fd());

//     EventLoop baseloop;
//     Channel channel(sock.Fd(), &baseloop);
//     channel.SetReadCallback(std::bind(Accept, &channel, &baseloop));
//     channel.EnableRead();

//     baseloop.Start();

//     return 0;
// }


// uint64_t task_id = 1;

// void ClosedCB(Channel* channel)
// {
//     INF_LOG("closed socket fd: %d", channel->Fd());
//     channel->RemoveEvents();
//     close(channel->Fd());
//     delete channel;
// }
// void MessageCB(Channel* channel)
// {
//     DBG_LOG("读事件处理回调");
//     char buf[1024] = { 0 };
//     int n = recv(channel->Fd(), buf, 1023, 0);
//     if(n <= 0)// 读取出错或连接断开
//     {
//         ERR_LOG("server recv failed，close socket");
//         ClosedCB(channel);
//         return;
//     }

//     INF_LOG("client say: %s", buf);

//     // 接收到数据才会发送数据
//     channel->EnableWrite();
// }
// void WriteCB(Channel* channel)
// {
//     DBG_LOG("写事件处理回调");
//     const char* str = "hello world";
//     int n = send(channel->Fd(), str, strlen(str), 0);
//     if(n < 0)
//     {
//         ERR_LOG("server send failed， close socket");
//         ClosedCB(channel);
//         return;
//     }

//     // 发送完数据就关闭可写监控，等待客户端数据到来再发送
//     channel->DisableWrite();
// }
// void ErrorCB(Channel* channel)
// {
//     DBG_LOG("错误事件处理回调");
//     ClosedCB(channel);
// }
// void EventCB(Channel* channel, EventLoop* eventloop, uint64_t task_id)
// {
//     DBG_LOG("有事件就绪");
//     eventloop->RefreshTimerTask(task_id);
// }

// void Accept(Channel* channel, EventLoop* eventloop)
// {
//     int new_sockfd = accept(channel->Fd(), nullptr, nullptr);// 获取新连接
//     if(new_sockfd < 0)
//     {
//         ERR_LOG("socket accept failed");
//         abort();
//     }

//     // 为新的通信连接创造Channel对象管理新连接上的事件监控
//     Channel* new_channel = new Channel(new_sockfd, eventloop);
//     // 为新连接的Channel对象设置事件被触发的回调函数
//     new_channel->SetReadCallback(std::bind(MessageCB, new_channel));
//     new_channel->SetWriteCallback(std::bind(WriteCB, new_channel));
//     new_channel->SetClosedCallback(std::bind(ClosedCB, new_channel));
//     new_channel->SetErrorCallback(std::bind(ErrorCB, new_channel));
//     new_channel->SetEventCallback(std::bind(EventCB, new_channel, eventloop, task_id));

//     eventloop->AddTimerTask(task_id, std::bind(ClosedCB, new_channel), 10);
//     eventloop->CancelTimerTask(task_id);
//     ++task_id;
//     // 启动读事件监控
//     new_channel->EnableRead();

//     INF_LOG("new socket：%d come", new_sockfd);
// }

// int main()
// {
//     Socket sock;
//     assert(sock.CreateServer(9000));
//     INF_LOG("server listen_socket created %d", sock.Fd());

//     EventLoop baseloop;
//     Channel channel(sock.Fd(), &baseloop);
//     channel.SetReadCallback(std::bind(Accept, &channel, &baseloop));
//     // DBG_LOG("start listenfd readable");
//     channel.EnableRead();

//     baseloop.Start();

//     return 0;
// }




// uint64_t task_id = 1;
// uint64_t conn_id = 1;
// using ConnectionPtr = std::shared_ptr<Connection>;

// std::unordered_map<uint64_t, ConnectionPtr> _conns;

// void ClosedCB(ConnectionPtr& conn)
// {
//     INF_LOG("connection: %ld has closed", conn->Id());
// }
// void ConnectedCB(ConnectionPtr& conn)
// {
//     INF_LOG("connection: %ld has established", conn->Id());
// }
// void MessageCB(ConnectionPtr& conn, Buffer* buf)
// {
//     std::string str;
//     buf->ReadAsStringAndPop(str, buf->ReadAbleSize());
//     INF_LOG("connection: %ld recv message: %s", conn->Id(), str.c_str());

//     conn->Send("this is server, have recv your message");

//     // conn->Close();// 这里测试只进行单次通信
// }
// void EventCB(ConnectionPtr& conn, EventLoop* eventloop, uint64_t task_id)
// {
//     DBG_LOG("有事件就绪");
//     eventloop->RefreshTimerTask(task_id);
// }

// void RemoveConnection(uint64_t conn_id)
// {
//     _conns.erase(conn_id);
// }

// void Accept(Channel* channel, EventLoop* eventloop)
// {
//     int new_sockfd = accept(channel->Fd(), nullptr, nullptr);// 获取新连接
//     if(new_sockfd < 0)
//     {
//         ERR_LOG("socket accept failed");
//         abort();
//     }

//     // 为新的通信连接创造Connection对象管理新连接
//     ConnectionPtr conn(new Connection(conn_id, eventloop, new_sockfd));
//     // 为新连接的Channel对象设置事件被触发的回调函数
//     conn->SetConnectedCallback(std::bind(ConnectedCB, conn));
//     conn->SetMessageCallback(std::bind(MessageCB, conn, std::placeholders::_1));
//     conn->SetClosedCallback(std::bind(ClosedCB, conn));
//     conn->SetEventCallback(std::bind(EventCB, conn, eventloop, task_id));
//     conn->SetSvrClosedCallback(std::bind(RemoveConnection, conn_id));

//     // 启动非活跃销毁功能
//     conn->EnableIdleRelease(2);
//     conn->DisableIdleRelease();

//     // 前面只是通信套接字创建成功，还要初始化用户态连接
//     conn->ConnectionEstablished();

//     // 走到这里，用户态连接真正创建完成，添加对用户态连接的管理
//     _conns.insert(std::make_pair(conn_id, conn));

//     ++task_id;
//     ++conn_id;
    
//     // INF_LOG("new socket：%d come", new_sockfd);
// }

// int main()
// {
//     Socket sock;
//     assert(sock.CreateServer(9000));
//     INF_LOG("server listen_socket created %d", sock.Fd());

//     EventLoop baseloop;
//     Channel channel(sock.Fd(), &baseloop);
//     channel.SetReadCallback(std::bind(Accept, &channel, &baseloop));
//     // DBG_LOG("start listenfd readable");
//     channel.EnableRead();

//     baseloop.Start();

//     return 0;
// }




// uint64_t task_id = 1;
// uint64_t conn_id = 1;
// using ConnectionPtr = std::shared_ptr<Connection>;

// std::unordered_map<uint64_t, ConnectionPtr> _conns;

// void ClosedCB(ConnectionPtr& conn)
// {
//     INF_LOG("connection: %ld has closed", conn->Id());
// }
// void ConnectedCB(ConnectionPtr& conn)
// {
//     INF_LOG("connection: %ld has established", conn->Id());
// }
// void MessageCB(ConnectionPtr& conn, Buffer* buf)
// {
//     std::string str;
//     buf->ReadAsStringAndPop(str, buf->ReadAbleSize());
//     INF_LOG("connection: %ld recv message: %s", conn->Id(), str.c_str());

//     conn->Send("this is server, have recv your message");

//     // conn->Close();// 这里测试只进行单次通信
// }
// void EventCB(ConnectionPtr& conn, EventLoop* eventloop, uint64_t task_id)
// {
//     DBG_LOG("有事件就绪");
//     eventloop->RefreshTimerTask(task_id);
// }

// void RemoveConnection(uint64_t conn_id)
// {
//     _conns.erase(conn_id);
// }

// void Accept(EventLoop* eventloop, int sockfd)
// {
//     // 为新的通信连接创造Connection对象管理新连接
//     ConnectionPtr conn(new Connection(conn_id, eventloop, sockfd));
//     // 为新连接的Channel对象设置事件被触发的回调函数
//     conn->SetConnectedCallback(std::bind(ConnectedCB, conn));
//     conn->SetMessageCallback(std::bind(MessageCB, conn, std::placeholders::_1));
//     conn->SetClosedCallback(std::bind(ClosedCB, conn));
//     conn->SetEventCallback(std::bind(EventCB, conn, eventloop, task_id));
//     conn->SetSvrClosedCallback(std::bind(RemoveConnection, conn_id));

//     // 启动非活跃销毁功能
//     conn->EnableIdleRelease(2);
//     // conn->DisableIdleRelease();

//     // 前面只是通信套接字创建成功，还要初始化用户态连接
//     conn->ConnectionEstablished();

//     // 走到这里，用户态连接真正创建完成，添加对用户态连接的管理
//     _conns.insert(std::make_pair(conn_id, conn));

//     ++task_id;
//     ++conn_id;
    
//     // INF_LOG("new socket：%d come", new_sockfd);
// }

// int main()
// {
//     EventLoop baseloop;

//     Acceptor acceptor(&baseloop, 9000);
//     INF_LOG("server listen_socket created %d", acceptor.Fd());
//     acceptor.SetAcceptedCallback(std::bind(Accept, &baseloop, std::placeholders::_1));
//     acceptor.Listen();// 启动读事件监控

//     baseloop.Start();

//     return 0;
// }




// uint64_t task_id = 1;
// uint64_t conn_id = 1;
// using ConnectionPtr = std::shared_ptr<Connection>;

// std::unordered_map<uint64_t, ConnectionPtr> _conns;

// void ClosedCB(ConnectionPtr& conn)
// {
//     INF_LOG("connection: %ld has closed", conn->Id());
// }
// void ConnectedCB(ConnectionPtr& conn)
// {
//     INF_LOG("connection: %ld has established", conn->Id());
// }
// void MessageCB(ConnectionPtr& conn, Buffer* buf)
// {
//     std::string str;
//     buf->ReadAsStringAndPop(str, buf->ReadAbleSize());
//     INF_LOG("connection: %ld recv message: %s", conn->Id(), str.c_str());

//     conn->Send("this is server, have recv your message");

//     conn->Close();// 这里测试只进行单次通信
// }
// void EventCB(ConnectionPtr& conn, EventLoop* eventloop, uint64_t task_id)
// {
//     DBG_LOG("有事件就绪");
//     eventloop->RefreshTimerTask(task_id);
// }

// void RemoveConnection(uint64_t conn_id)
// {
//     _conns.erase(conn_id);
// }

// void Accept(EventLoop* eventloop, LoopThreadPool* threadpool, int sockfd)
// {
//     // 为新的通信连接创造Connection对象管理新连接
//     ConnectionPtr conn(new Connection(conn_id, threadpool->NextLoop(), sockfd));
//     // 为新连接的Channel对象设置事件被触发的回调函数
//     conn->SetConnectedCallback(std::bind(ConnectedCB, conn));
//     conn->SetMessageCallback(std::bind(MessageCB, conn, std::placeholders::_1));
//     conn->SetClosedCallback(std::bind(ClosedCB, conn));
//     conn->SetEventCallback(std::bind(EventCB, conn, eventloop, task_id));
//     conn->SetSvrClosedCallback(std::bind(RemoveConnection, conn_id));

//     // 启动非活跃销毁功能
//     conn->EnableIdleRelease(2);
//     // conn->DisableIdleRelease();

//     // 前面只是通信套接字创建成功，还要初始化用户态连接
//     conn->ConnectionEstablished();

//     // 走到这里，用户态连接真正创建完成，添加对用户态连接的管理
//     _conns.insert(std::make_pair(conn_id, conn));

//     ++task_id;
//     ++conn_id;
    
//     // INF_LOG("new socket：%d come", new_sockfd);
// }

// int main()
// {
//     EventLoop baseloop;
//     LoopThreadPool threadpool(&baseloop);
//     threadpool.SetThreadCount(2);
//     threadpool.CreateThreads();

//     Acceptor acceptor(&baseloop, 9000);
//     INF_LOG("server listen_socket created %d", acceptor.Fd());
//     acceptor.SetAcceptedCallback(std::bind(Accept, &baseloop, &threadpool, std::placeholders::_1));
//     acceptor.Listen();// 启动读事件监控

//     baseloop.Start();

//     return 0;
// }




#include "../src/Server.hpp"

void OnClosed(const ConnectionPtr& conn)
{
    INF_LOG("connection: %ld with socket: %d has closed", conn->Id(), conn->TmpFd());
}
void OnConnected(const ConnectionPtr& conn)
{
    INF_LOG("connection: %ld has established, socket: %d", conn->Id(), conn->TmpFd());
}
void OnMessage(const ConnectionPtr& conn, Buffer* buf)
{
    // INF_LOG("server recv from client: %s", buf->ReadPosition());
    buf->MoveReadOffset(buf->ReadAbleSize());

    // conn->Send("server has recv your message");
    // conn->Close();
}

int main()
{
    // 1. 创建服务器
    TcpServer server(9000);
    // 2. 设置线程池大小
    server.SetLoopThreadCount(5);
    // 3. 启动非活跃连接超时销毁
    server.EnableIdelRelease(10);
    // 4. 设置回调函数
#if 1
    server.SetConnectedCallback(OnConnected);
    server.SetClosedCallback(OnClosed);
    server.SetMessageCallback(OnMessage);
#else
    server.SetConnectedCallback(std::bind(&OnConnected, std::placeholders::_1));
    server.SetClosedCallback(std::bind(&OnClosed, std::placeholders::_1));
    server.SetMessageCallback(std::bind(&OnMessage, std::placeholders::_1, std::placeholders::_2));
#endif
    INF_LOG("Server has established");

    // 5. 启动服务器
    server.Start();


    return 0;
}